package com.sdy.utils;

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.concurrent.TimeUnit;


/**
 * 工具类对象
 */
@SuppressWarnings("all")
public class RedisUtil {

    private RedisTemplate<String,Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    //获取普通类缓存数据
    public Object get (String key) {
        //如果是空的就返回空的，否则查
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    //使用pipline批量查询数据
    public List<Object> getByPipline (List<String> keyList) {
        // 使用匿名类实现
        List<Object> list = redisTemplate.executePipelined(new SessionCallback() {
            @Override
            public Object execute(RedisOperations ops) throws DataAccessException {
                // 在流水线下，命令不会马上返回结果，结果是一次性执行后返回的
                for (String key:keyList) {
                    ops.opsForValue().get(key);
                }
                return null;
            };
        });
        return list;
    }

    //存储普通类缓存数据
    public Boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        }
        catch (Exception e){
            System.out.println("出错了");
            e.printStackTrace();
            return false;
        }
    }

    //在存入完成后 设置缓存数据失效时间
    public Boolean expire(String key,long time){
        try {
            if (time > 0){
                //expire(key值，时间，时间单位）
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        }
        catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }


    //在存入时 设置缓存数据失效时间
    public Boolean set(String key,Object value,long time){
        try {
            if (time > 0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }
            else {
                set(key,value);
            }
            return true;
        }
        catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //判断key是否存在
    public Boolean hasKey(String key){
        System.out.println(key);
        try {
            return redisTemplate.hasKey(key);
        }
        catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

//    // 删除缓存
//    public void delet(String... key){
//        if (key != null && key.length > 0){
//            if (key.length == 1){
//                redisTemplate.delete(key[0]);
//            }
//            else {
//                redisTemplate.delete(CollectionUtils.arrayToList(key));
//            }
//        }
//    }

    //获取集合类型数据
    public List<Object> getList(String key){
        return redisTemplate.opsForList().range(key,0,-1);
    }

    //存放集合类型数据
    public void setList(String key, List list){
        redisTemplate.opsForList().leftPushAll(key,list);
    }
}



























